package com.xp.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.xp.entity.Role;
import com.xp.entity.UserRole;
import com.xp.mapper.RoleMapper;
import com.xp.mapper.UserRoleMapper;
import com.xp.service.RoleService;
import com.xp.utils.Result;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.time.LocalDateTime;
import java.util.List;

/**
 * 角色服务实现类
 * 
 * @author xp
 * @since 2024-01-01
 */
@Service
@RequiredArgsConstructor
public class RoleServiceImpl extends BaseServiceImpl<RoleMapper, Role> implements RoleService {

    private static final Logger log = LoggerFactory.getLogger(RoleServiceImpl.class);

    private final RoleMapper roleMapper;
    private final UserRoleMapper userRoleMapper;

    /**
     * 分页查询角色列表
     */
    @Override
    public Result<IPage<Role>> getRolePage(Page<Role> page, String roleName, Integer status) {
        try {
            IPage<Role> rolePage = roleMapper.selectRolePage(page, roleName, status);
            return Result.success(rolePage);
        } catch (Exception e) {
            log.error("分页查询角色列表失败", e);
            return Result.error("查询角色列表失败");
        }
    }

    /**
     * 新增角色
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result<Object> createRole(Role role) {
        try {
            // 验证角色编码唯一性
            if (StringUtils.hasText(role.getRoleCode())) {
                Role existingRole = roleMapper.selectByRoleCode(role.getRoleCode());
                if (existingRole != null) {
                    return Result.error("角色编码已存在");
                }
            }

            // 验证角色名称唯一性
            if (StringUtils.hasText(role.getRoleName())) {
                Role existingRole = roleMapper.selectByRoleName(role.getRoleName());
                if (existingRole != null) {
                    return Result.error("角色名称已存在");
                }
            }

            // 设置默认值
            if (role.getStatus() == null) {
                role.setStatus(1); // 默认启用
            }
            if (role.getSortOrder() == null) {
                role.setSortOrder(0);
            }

            int result = roleMapper.insert(role);
            if (result > 0) {
                log.info("新增角色成功，角色ID：{}", role.getId());
                return Result.success("新增角色成功");
            } else {
                return Result.error("新增角色失败");
            }
        } catch (Exception e) {
            log.error("新增角色失败", e);
            return Result.error("新增角色失败");
        }
    }

    /**
     * 更新角色
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result<Object> updateRole(Role role) {
        try {
            if (role.getId() == null) {
                return Result.error("角色ID不能为空");
            }

            // 检查角色是否存在
            Role existingRole = roleMapper.selectById(role.getId());
            if (existingRole == null) {
                return Result.error("角色不存在");
            }

            // 验证角色编码唯一性（排除自己）
            if (StringUtils.hasText(role.getRoleCode())) {
                Role roleByCode = roleMapper.selectByRoleCode(role.getRoleCode());
                if (roleByCode != null && !roleByCode.getId().equals(role.getId())) {
                    return Result.error("角色编码已存在");
                }
            }

            // 验证角色名称唯一性（排除自己）
            if (StringUtils.hasText(role.getRoleName())) {
                Role roleByName = roleMapper.selectByRoleName(role.getRoleName());
                if (roleByName != null && !roleByName.getId().equals(role.getId())) {
                    return Result.error("角色名称已存在");
                }
            }

            int result = roleMapper.updateById(role);
            if (result > 0) {
                log.info("更新角色成功，角色ID：{}", role.getId());
                return Result.success("更新角色成功");
            } else {
                return Result.error("更新角色失败");
            }
        } catch (Exception e) {
            log.error("更新角色失败", e);
            return Result.error("更新角色失败");
        }
    }

    /**
     * 删除角色
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result<Object> deleteRole(Long roleId) {
        try {
            if (roleId == null) {
                return Result.error("角色ID不能为空");
            }

            // 检查角色是否存在
            Role role = roleMapper.selectById(roleId);
            if (role == null) {
                return Result.error("角色不存在");
            }

            // 检查是否有用户关联此角色
            List<UserRole> userRoles = userRoleMapper.selectByRoleId(roleId);
            if (!userRoles.isEmpty()) {
                return Result.error("该角色下还有用户，无法删除");
            }

            // 逻辑删除角色
            int result = roleMapper.deleteById(roleId);
            if (result > 0) {
                log.info("删除角色成功，角色ID：{}", roleId);
                return Result.success("删除角色成功");
            } else {
                return Result.error("删除角色失败");
            }
        } catch (Exception e) {
            log.error("删除角色失败", e);
            return Result.error("删除角色失败");
        }
    }

    /**
     * 根据ID获取角色详情
     */
    @Override
    public Result<Role> getRoleById(Long roleId) {
        try {
            if (roleId == null) {
                return Result.error("角色ID不能为空");
            }

            Role role = roleMapper.selectById(roleId);
            if (role == null) {
                return Result.error("角色不存在");
            }

            return Result.success(role);
        } catch (Exception e) {
            log.error("获取角色详情失败", e);
            return Result.error("获取角色详情失败");
        }
    }

    /**
     * 获取所有启用的角色
     */
    @Override
    public Result<List<Role>> getEnabledRoles() {
        try {
            List<Role> roles = roleMapper.selectEnabledRoles();
            return Result.success(roles);
        } catch (Exception e) {
            log.error("获取启用角色列表失败", e);
            return Result.error("获取启用角色列表失败");
        }
    }

    /**
     * 根据用户ID获取用户的角色列表
     */
    @Override
    public Result<List<Role>> getRolesByUserId(Long userId) {
        try {
            if (userId == null) {
                return Result.error("用户ID不能为空");
            }

            List<Role> roles = roleMapper.selectRolesByUserId(userId);
            return Result.success(roles);
        } catch (Exception e) {
            log.error("获取用户角色列表失败", e);
            return Result.error("获取用户角色列表失败");
        }
    }

    /**
     * 为用户分配角色
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result<Object> assignRolesToUser(Long userId, List<Long> roleIds) {
        try {
            if (userId == null) {
                return Result.error("用户ID不能为空");
            }

            // 先删除用户现有的角色关联
            userRoleMapper.deleteByUserId(userId);

            // 添加新的角色关联
            if (roleIds != null && !roleIds.isEmpty()) {
                for (Long roleId : roleIds) {
                    UserRole userRole = new UserRole();
                    userRole.setUserId(userId);
                    userRole.setRoleId(roleId);
                    userRole.setCreateTime(LocalDateTime.now());
                    userRole.setUpdateTime(LocalDateTime.now());
                    userRoleMapper.insert(userRole);
                }
            }

            log.info("为用户分配角色成功，用户ID：{}，角色数量：{}", userId, roleIds != null ? roleIds.size() : 0);
            return Result.success("分配角色成功");
        } catch (Exception e) {
            log.error("为用户分配角色失败", e);
            return Result.error("分配角色失败");
        }
    }

    /**
     * 移除用户的角色
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result<Object> removeUserRole(Long userId, Long roleId) {
        try {
            if (userId == null || roleId == null) {
                return Result.error("用户ID和角色ID不能为空");
            }

            int result = userRoleMapper.deleteByUserIdAndRoleId(userId, roleId);
            if (result > 0) {
                log.info("移除用户角色成功，用户ID：{}，角色ID：{}", userId, roleId);
                return Result.success("移除角色成功");
            } else {
                return Result.error("用户角色关联不存在");
            }
        } catch (Exception e) {
            log.error("移除用户角色失败", e);
            return Result.error("移除角色失败");
        }
    }

    /**
     * 获取用户角色关联列表
     */
    @Override
    public Result<List<UserRole>> getUserRoleList(Long userId, Long roleId) {
        try {
            LambdaQueryWrapper<UserRole> wrapper = new LambdaQueryWrapper<>();
            
            if (userId != null) {
                wrapper.eq(UserRole::getUserId, userId);
            }
            
            if (roleId != null) {
                wrapper.eq(UserRole::getRoleId, roleId);
            }

            List<UserRole> userRoles = userRoleMapper.selectList(wrapper);
            return Result.success(userRoles);
        } catch (Exception e) {
            log.error("获取用户角色关联列表失败", e);
            return Result.error("获取用户角色关联列表失败");
        }
    }

    /**
     * 更新角色状态
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result<Object> updateRoleStatus(Long roleId, Integer status) {
        try {
            if (roleId == null) {
                return Result.error("角色ID不能为空");
            }
            
            if (status == null || (status != 0 && status != 1)) {
                return Result.error("状态值无效，只能是0（禁用）或1（启用）");
            }

            // 检查角色是否存在
            Role role = roleMapper.selectById(roleId);
            if (role == null) {
                return Result.error("角色不存在");
            }

            // 更新角色状态
            role.setStatus(status);
            role.setUpdateTime(LocalDateTime.now());
            
            int result = roleMapper.updateById(role);
            if (result > 0) {
                log.info("更新角色状态成功，角色ID：{}，状态：{}", roleId, status);
                return Result.success("更新角色状态成功");
            } else {
                return Result.error("更新角色状态失败");
            }
        } catch (Exception e) {
            log.error("更新角色状态失败", e);
            return Result.error("更新角色状态失败");
        }
    }

    /**
     * 为角色分配用户
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result<Object> assignUsersToRole(Long roleId, List<Long> userIds) {
        try {
            if (roleId == null) {
                return Result.error("角色ID不能为空");
            }

            // 检查角色是否存在
            Role role = roleMapper.selectById(roleId);
            if (role == null) {
                return Result.error("角色不存在");
            }

            // 先删除角色现有的用户关联
            userRoleMapper.deleteByRoleId(roleId);

            // 添加新的用户关联
            if (userIds != null && !userIds.isEmpty()) {
                for (Long userId : userIds) {
                    UserRole userRole = new UserRole();
                    userRole.setUserId(userId);
                    userRole.setRoleId(roleId);
                    userRole.setCreateTime(LocalDateTime.now());
                    userRole.setUpdateTime(LocalDateTime.now());
                    userRoleMapper.insert(userRole);
                }
            }

            log.info("为角色分配用户成功，角色ID：{}，用户数量：{}", roleId, userIds != null ? userIds.size() : 0);
            return Result.success("分配用户成功");
        } catch (Exception e) {
            log.error("为角色分配用户失败", e);
            return Result.error("分配用户失败");
        }
    }
}